home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / FIND.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-04  |  30.2 KB  |  1,346 lines
  1. #include "global.h"
  2. #include "ausgabe.h"
  3. #include "block.h"
  4. #include "clipbrd.h"
  5. #include "comm.h"
  6. #include "edit.h"
  7. #include "event.h"
  8. #include "icon.h"
  9. #include "mintlib.h"
  10. #include "obj.h"
  11. #include "rsc.h"
  12. #include "scroll.h"
  13. #include "set.h"
  14. #include "tasten.h"
  15. #include "text.h"
  16. #include "windows.h"
  17. #include "find.h"
  18.  
  19.  
  20. /* exportierte Variablen ***************************************************/
  21.  
  22. GLOBAL BOOLEAN                s_grkl, s_quant, s_wort, s_runter, s_global, s_round,
  23.                                 df_rekursiv;
  24. GLOBAL WORD                    r_modus, rp_box_x, rp_box_y;
  25. GLOBAL UBYTE                r_str[HIST_LEN+1], s_str[HIST_LEN+1],
  26.                                 s_history[HIST_ANZ][HIST_LEN+1],
  27.                                 df_name[MUSTER_LEN+1];
  28.  
  29. GLOBAL UmlautEncoding     umlaut_from, umlaut_to;
  30.  
  31. /*****************************************************************************/
  32.  
  33. #define SETANZ         5
  34.  
  35. #define M_CURSOR        0        /* Werte für modus von start_suche */
  36. #define M_TSTART        1
  37. #define M_TENDE        2
  38.  
  39. LOCAL LINEP     start;
  40. LOCAL WORD        text_len, text_x,
  41.                     last_op = -1;
  42. LOCAL LONG        text_y;
  43. LOCAL SET        wort_set;
  44. LOCAL WORD        edobj;
  45.  
  46. /* Variablen, die über set_suchmode gesetzt werden */
  47. /* !!! muessen bei match gesichet werden !!! */
  48. LOCAL BOOLEAN    quantor, runter, grkl, wort, modus, round, line_start;
  49. LOCAL WORD        muster_len;
  50. LOCAL UBYTE     muster_txt[80];
  51. LOCAL SET        group[SETANZ];
  52. LOCAL WORD        setanz;
  53. LOCAL WORD        delta[256];
  54.  
  55. /* lokale Prototypen *****************************************************/
  56. LOCAL BOOLEAN    build_popup (POPUP_STRUK *pop);
  57. LOCAL WORD        hist_popup    (OBJECT *tree, WORD obj_pos, WORD obj_text);
  58.  
  59. /*=======================================================================*/
  60.  
  61. LOCAL VOID init_suche(TEXTP t_ptr, WORD modus)
  62. {
  63.     if (modus == M_CURSOR)
  64.     {
  65.         start = t_ptr->cursor_line;
  66.         text_y = t_ptr->ypos;
  67.         if (runter)
  68.         {
  69.             text_x = t_ptr->xpos;
  70.             text_len = start->len-t_ptr->xpos;
  71.             if (text_len>0)
  72.             {
  73.                 text_x++;
  74.                 text_len--;
  75.             }
  76.             else if (!IS_LAST(start))
  77.             {
  78.                 NEXT(start);
  79.                 text_y++;
  80.                 text_x = 0;
  81.                 text_len = start->len;
  82.             }
  83.         }
  84.         else
  85.         {
  86.             text_x = 0;
  87.             text_len = t_ptr->xpos;
  88.             if (text_len>0)
  89.             {
  90.                 text_len--;
  91.             }
  92.             else if (!IS_FIRST(start))
  93.             {
  94.                 VORG(start);
  95.                 text_y--;
  96.                 text_len = start->len;
  97.             }
  98.         }
  99.     }
  100.     else if (modus==M_TSTART)
  101.     {
  102.         start = FIRST(&t_ptr->text);
  103.         text_x = 0;
  104.         text_len = start->len;
  105.         text_y = 0;
  106.     }
  107.     else
  108.     {
  109.         start = LAST(&t_ptr->text);
  110.         text_x = 0;
  111.         text_len = start->len;
  112.         text_y = t_ptr->text.lines-1;
  113.     }
  114.     setcpy(wort_set,t_ptr->loc_opt->wort_set);
  115. }
  116.  
  117. LOCAL WORD suche1(LINEP col, WORD x, WORD str_len, WORD *such_len,
  118.                         UBYTE*(*call)(UBYTE*,WORD,UBYTE*,WORD*))
  119. /* runter */
  120. {
  121.     UBYTE *ptr, *str, *str2;
  122.  
  123.     if (quantor)
  124.     {
  125.         if (x>0 && line_start)                                    /* Muster am Anfang finden */
  126.             return -1;
  127.         if (x+str_len<col->len && muster_len>=2 &&
  128.              muster_txt[muster_len-2]=='[' && muster_txt[muster_len-1]==0xFC)
  129.             return -1;
  130.     }
  131.     ptr = TEXT(col);
  132.     str = ptr+x;
  133.     str2 = (*call)(str, str_len, muster_txt, such_len);
  134.     if (str2==NULL) return -1;
  135.     if (wort)
  136.     {
  137.         while (!(str2==ptr || !setin(wort_set,str2[-1])) ||
  138.                  !(str2[*such_len]==EOS || !setin(wort_set,str2[*such_len])))
  139.         {
  140.             str2++;
  141.             str_len -= (short)(str2 - str);
  142.             str = str2;
  143.             str2 = (*call)(str, str_len, muster_txt, such_len);
  144.             if (str2==NULL) return -1;
  145.         }
  146.     }
  147.     return (short)(str2 - ptr);
  148. }
  149.  
  150. LOCAL WORD suche2(LINEP col, WORD x, WORD str_len, WORD *such_len,
  151.                         UBYTE*(*call)(UBYTE*,WORD,UBYTE*,WORD*))
  152. /* rauf */
  153. {
  154.     WORD    x2, merk;
  155.  
  156.     merk = 0;
  157.     while (TRUE)
  158.     {
  159.         x2 = suche1(col, x, str_len, such_len, call);
  160.         if (x2==-1) break;
  161.         x2++;                                 /* Weiter suchen */
  162.         str_len -= x2-x;                    /* Restlänge */
  163.         merk = x = x2;
  164.     }
  165.     return merk-1;
  166. }
  167.  
  168. LOCAL UBYTE *STRSTR(UBYTE *str_anf, WORD str_len, UBYTE *mstr_anf, WORD *found_len)
  169. /* Suche ohne Quantoren */
  170. {
  171.     UBYTE *mstr, *str;
  172.     WORD    i, mstr_len = muster_len;
  173.  
  174.     *found_len = mstr_len;
  175.     str_anf += mstr_len;
  176.     str_len -= mstr_len;
  177.     mstr_anf += mstr_len;
  178.     while (str_len>=0)
  179.     {
  180.         str = str_anf;
  181.         mstr = mstr_anf;
  182.         i = mstr_len;
  183.         while(TRUE)
  184.         {
  185.             if (*(--mstr)!=*(--str)) break;        /* Match fehlgeschlagen */
  186.             if ((--i)<=0) return(str);             /* gefunden */
  187.             if (*(--mstr)!=*(--str)) break;        /* Match fehlgeschlagen */
  188.             if ((--i)<=0) return(str);                /* gefunden */
  189.             if (*(--mstr)!=*(--str)) break;        /* Match fehlgeschlagen */
  190.             if ((--i)<=0) return(str);             /* gefunden */
  191.             if (*(--mstr)!=*(--str)) break;        /* Match fehlgeschlagen */
  192.             if ((--i)<=0) return(str);             /* gefunden */
  193.         }
  194.         i = delta[str_anf[-1]];
  195.         str_anf += i;                                        /* weiterrücken */
  196.         str_len -= i;
  197.     }
  198.     return(NULL);
  199. }
  200.  
  201. LOCAL UBYTE *STRSTR1(UBYTE *str_anf, WORD str_len, UBYTE *mstr_anf, WORD *found_len)
  202. /* Suche ohne Quantoren (Gross/Klein) */
  203. {
  204.     UBYTE *mstr, *str, s;
  205.     WORD    i, mstr_len = muster_len;
  206.  
  207.     *found_len = mstr_len;
  208.     str_anf += mstr_len;
  209.     str_len -= mstr_len;
  210.     mstr_anf += mstr_len;
  211.     while (str_len>=0)
  212.     {
  213.         str = str_anf;
  214.         mstr = mstr_anf;
  215.         i = mstr_len;
  216.         while (TRUE)
  217.         {
  218.             s = *(--str);
  219.             if (s>='a' && s<='z') s-=32;
  220.             else if (s=='ö') s = 'Ö';
  221.             else if (s=='ü') s = 'Ü';
  222.             else if (s=='ä') s = 'Ä';
  223.             if (*(--mstr)!=s) break;                    /* Match fehlgeschlagen */
  224.             if ((--i)<=0) return (str);                /* gefunden */
  225.         }
  226.         s = str_anf[-1];
  227.         if (s>='a' && s<='z') s-=32;
  228.         else if (s=='ö') s = 'Ö';
  229.         else if (s=='ü') s = 'Ü';
  230.         else if (s=='ä') s = 'Ä';
  231.         i = delta[s];
  232.         str_anf += i;                                        /* weiterrücken */
  233.         str_len -= i;
  234.     }
  235.     return(NULL);
  236. }
  237.  
  238. LOCAL UBYTE *STRSTR2(UBYTE *str_anf, WORD str_len, UBYTE *mstr_anf, WORD *found_len)
  239. /* Suche mit Quantoren (rekursiv) */
  240. {
  241.     UBYTE *str, *mstr, m, s;
  242.     WORD    len, anz;
  243.  
  244.     if (line_start)                                        /* Muster am Anfang finden */
  245.         anz = 1;
  246.     else
  247.         anz = str_len+1;                                    /* Anzahl der Tests */
  248.     while ((--anz)>=0)                                    /* auch len=0 kann Treffer sein */
  249.     {
  250.         mstr = mstr_anf;                                    /* Muster reset */
  251.         str = str_anf;                                     /* String reset */
  252.         len = str_len;
  253.         while (TRUE)
  254.         {
  255.             m = *mstr++;                                    /* neue Zeichen holen */
  256.             s = *str;
  257.             if (m==EOS)                                     /* Muster komplett gefunden */
  258.             {
  259.                 *found_len = (short)(str - str_anf);
  260.                 return str_anf;
  261.             }
  262.             if (len==0)
  263.                 s = EOS;
  264.  
  265.             if (m=='*')
  266.             {
  267.                 BOOLEAN    save = line_start;
  268.  
  269.                 line_start = FALSE;
  270.                 str = STRSTR2(str, len, mstr, found_len);
  271.                 line_start = save;
  272.                 if (str==NULL)
  273.                     return NULL;
  274.                 *found_len += (short)(str - str_anf);
  275.                 return str_anf;
  276.             }
  277.             if (!grkl)
  278.             {
  279.                 if (s>='a' && s<='z') s-=32;
  280.                 else if (s=='ö') s = 'Ö';
  281.                 else if (s=='ü') s = 'Ü';
  282.                 else if (s=='ä') s = 'Ä';
  283.             }
  284.             if (m=='[')
  285.             {
  286.                 m = *mstr++;                                /* nach '[' folgt ein Infozeichen */
  287.                 if (m==0xFF)                            /* echtes '[' */
  288.                 {
  289.                     if (s!='[') break;
  290.                 }
  291.                 else if (m==0xFE)                             /* Wortende (letztes in Muster) */
  292.                 {
  293.                     if (len==0 || !setin(wort_set,s))
  294.                     {
  295.                         *found_len = (short)(str - str_anf);
  296.                         return str_anf;
  297.                     }
  298.                     break;
  299.                 }
  300.                 else if (m==0xFC)                         /* Zeilenende */
  301.                 {
  302.                     if (len==0)
  303.                     {
  304.                         *found_len = (short)(str - str_anf);
  305.                         return str_anf;
  306.                     }
  307.                     break;
  308.                 }
  309.                 else                                            /* Wildcard */
  310.                 {
  311.                     if (!setin(group[m-1],s)) break;
  312.                 }
  313.             }
  314.             else                                                /* normale Zeichen und '?' */
  315.                 if (m!=s && m!='?') break;
  316.  
  317.             if (len==0) break;
  318.             str++; len--;                                    /* nächstes Zeichen */
  319.         }
  320.         str_anf++;                                            /* String ein Zeichen weiter */
  321.         str_len--;
  322.     }
  323.     return NULL;
  324. }
  325.  
  326. /* rein : start, text_x, text_len, text_y */
  327. /* raus : start, text_x, text_len, text_y */
  328. /* -1:Abbruch, 0:nichts gefunden 1:gefunden */
  329.  
  330. LOCAL WORD suchen2(TEXTP t_ptr, WORD *such_len)
  331. {
  332.     UBYTE*    (*call)    (UBYTE*,WORD,UBYTE*,WORD*);
  333.     LONG    y;
  334.     LINEP lauf;
  335.     WORD    step, x;
  336.  
  337.     x = text_x;
  338.     y = text_y;
  339.     lauf = start;
  340.     if (muster_len==0) return 0;
  341.     step = 70;
  342.     if (quantor)
  343.         call = STRSTR2;
  344.     else if (grkl)
  345.         call = STRSTR;
  346.     else
  347.         call = STRSTR1;
  348.     if (runter)
  349.     {
  350.         while (TRUE)
  351.         {
  352.             if ((text_x=suche1(lauf,x,text_len,such_len,call))>=0)
  353.             {
  354.                 text_y = y;
  355.                 start = lauf;
  356.                 return 1;
  357.             }
  358.             NEXT(lauf); y++; x = 0; text_len = lauf->len;
  359.             if (IS_TAIL(lauf)) return 0;
  360.             if ((--step)==0)
  361.             {
  362.                 if (abbruch() && note(1,BREAK)==1) return -1;
  363.                 step = 70;
  364.             }
  365.         }
  366.     }
  367.     else
  368.     {
  369.         while (TRUE)
  370.         {
  371.             if ((text_x=suche2(lauf,x,text_len,such_len,call))>=0)
  372.             {
  373.                 text_y = y;
  374.                 start = lauf;
  375.                 return 1;
  376.             }
  377.             VORG(lauf);
  378.             if (IS_HEAD(lauf)) return 0;
  379.             y--;
  380.             x = 0;
  381.             text_len = lauf->len;
  382.             if ((--step)==0)
  383.             {
  384.                 if (abbruch() && note(1,BREAK)==1) return -1;
  385.                 step = 70;
  386.             }
  387.         }
  388.     }
  389. }
  390.  
  391. /* rein : start, text_x, text_len, text_y */
  392. /* raus : start, text_x, text_len, text_y */
  393. /* -1:Abbruch, 0:nichts gefunden 1:gefunden */
  394.  
  395. LOCAL WORD suchen(TEXTP t_ptr, WORD *such_len)
  396. {
  397.     WORD    erg;
  398.  
  399.     erg = suchen2(t_ptr, such_len);
  400.     if (erg==0 && round)
  401.     {
  402.         WORD    m;
  403.  
  404.         mybeep();
  405.         if (runter)
  406.             m = M_TSTART;
  407.         else
  408.             m = M_TENDE;
  409.         init_suche(t_ptr,m);
  410.         erg = suchen2(t_ptr, such_len);
  411.     }
  412.     return erg;
  413. }
  414.  
  415. /* ====================================================================== */
  416.  
  417. GLOBAL VOID set_suchmode(UBYTE *Muster, BOOLEAN Grkl, BOOLEAN Quantor, BOOLEAN Runter,
  418.                                 BOOLEAN Wort, BOOLEAN Global, BOOLEAN Round)
  419. {
  420.     UBYTE *ptr, *d, help[80];
  421.     BOOLEAN    invers;
  422.  
  423.     strcpy(muster_txt, Muster);
  424.     grkl = Grkl;
  425.     quantor = Quantor;
  426.     runter = Runter;
  427.     wort = Wort;
  428.     round = Round;
  429.     setanz = 0;
  430.     if (!grkl) str_upper(muster_txt);
  431.     if (quantor)
  432.     {
  433.         d = help;
  434.         ptr = muster_txt;
  435.         if (*ptr=='^')
  436.         {
  437.             line_start = TRUE;
  438.             ptr++;
  439.         }
  440.         else
  441.             line_start = FALSE;
  442.  
  443.         for (; *ptr; ptr++)
  444.         {
  445.             *d++ = *ptr;
  446.             if (*ptr=='$' && ptr[1]==EOS)
  447.             {
  448.                 d[-1] = '[';
  449.                 *d++ = 0xFC;
  450.             }
  451.             else if (*ptr=='[' && setanz<SETANZ)
  452.             {
  453.                 UBYTE *merk = ptr;
  454.  
  455.                 ptr++;
  456.                 invers = FALSE;
  457.                 if (*ptr=='^')
  458.                 {
  459.                     invers = TRUE;
  460.                     ptr++;
  461.                 }
  462.                 setclr(group[setanz]);
  463.                 while(*ptr && *ptr!=']')
  464.                 {
  465.                     if (ptr[0]=='-' && ptr[-1]!='[' && ptr[1]!=']')
  466.                     {
  467.                         UBYTE i;
  468.  
  469.                         ptr++;
  470.                         for (i=ptr[-2]; i<*ptr; i++)
  471.                             setincl(group[setanz],i);
  472.                     }
  473.                     else
  474.                         setincl(group[setanz],*ptr++);
  475.                 }
  476.                 if (*ptr)                            /* Keine ']' gefunden */
  477.                 {
  478.                     if (invers)
  479.                         setnot(group[setanz]);
  480.                     setanz++;
  481.                     *d++ = setanz;                 /* immer einen grö₧er (weil nie Null) */
  482.                 }
  483.                 else
  484.                 {
  485.                     *d++ = 0xFF;                    /* Echtes '[' */
  486.                     ptr = merk;                     /* Neu Scannen */
  487.                 }
  488.             }
  489.         }
  490.         if (wort && d>help)                        /* nur Worte und überhaupt ein Muster */
  491.         {
  492.             *d++ = '[';
  493.             *d++ = 0xFE;                            /* Wortende */
  494.         }
  495.         *d = EOS;
  496.         strcpy(muster_txt,help);
  497.         muster_len = (short) strlen(muster_txt);
  498.     }
  499.     else
  500.     {
  501.         WORD i,j;
  502.  
  503.         muster_len = (short) strlen(muster_txt);
  504.         for (i=0; i<256; i++) delta[i] = muster_len;
  505.         j = muster_len-1;
  506.         for (i=0; i<j; i++) delta[muster_txt[i]] = j-i;
  507.     }
  508.     if (Global)
  509.     {
  510.         if (runter)
  511.             modus = M_TSTART;
  512.         else
  513.             modus = M_TENDE;
  514.     }
  515.     else
  516.             modus = M_CURSOR;
  517. }
  518.  
  519. GLOBAL WORD start_find(TEXTP t_ptr, BOOLEAN quiet)
  520. {
  521.     WORD    len, erg;
  522.  
  523.     last_op = 1;
  524.     Busy_mouse();
  525.     init_suche(t_ptr, modus);            /* Suchzeiger an den Start bringen */
  526.     erg = suchen(t_ptr,&len);
  527.     Last_mouse();
  528.     if (erg == 1 && !quiet)
  529.     {
  530.         blk_demark(t_ptr);
  531.         t_ptr->cursor_line = start;
  532.         t_ptr->xpos = text_x;
  533.         t_ptr->ypos = text_y;
  534.         make_chg(t_ptr->link,POS_CHANGE,0);
  535.         blk_mark(t_ptr,0);
  536.         t_ptr->xpos = text_x+len;
  537.         blk_mark(t_ptr,1);
  538.         restore_edit();
  539.     }
  540.     return erg;
  541. }
  542.  
  543. GLOBAL WORD start_replace(TEXTP t_ptr, BOOLEAN special)
  544. {
  545.     WORD        delta, erg,
  546.                 such_len, rpl_len;
  547.     LONG        anz;
  548.     DIALINFO    dial;
  549.  
  550.     last_op = 2;
  551.     Busy_mouse();
  552.     rpl_len    = (short) strlen(r_str);
  553.     anz = 0L;
  554.     init_suche(t_ptr, modus);
  555.  
  556.     /* Nur zentrieren, wenn kein andere Pos bekannt. */
  557.     if (rp_box_x == 0 && rp_box_y == 0)
  558.         dial_center(repask);
  559.     else
  560.     {
  561.         repask[0].ob_x = rp_box_x;
  562.         repask[0].ob_y = rp_box_y;
  563.     }
  564.     
  565.     while((erg=suchen(t_ptr, &such_len))==1)
  566.     {
  567.         delta = rpl_len-such_len;
  568.         if (start->len+delta>MAX_LINE_LEN)
  569.         {
  570.             inote(1, TOOLONG, MAX_LINE_LEN);
  571.             erg = -1;
  572.             break;
  573.         }
  574.         text_len = start->len-text_x;
  575.         t_ptr->cursor_line = start;
  576.         t_ptr->xpos = text_x;
  577.         t_ptr->ypos = text_y;
  578.         if (r_modus!=RP_ALL)             /* Optional oder einzeln */
  579.         {
  580.             blk_demark(t_ptr);
  581.             make_chg(t_ptr->link,POS_CHANGE,0);
  582.             restore_edit();
  583.             if (r_modus==RP_OPT)
  584.             {
  585.                 WORD antw;
  586.  
  587.                 blk_mark(t_ptr,0);
  588.                 t_ptr->xpos = text_x+such_len;
  589.                 blk_mark(t_ptr,1);
  590.                 restore_edit();
  591.                 open_dial(repask, FALSE, NULL, &dial);
  592.                 dial_draw(&dial);
  593.                 antw = dial_do(&dial, NULL) & 0x7FFF;
  594.                 undo_state(repask, antw, SELECTED);
  595.                 close_dial(FALSE, NULL, &dial);
  596.                 /* neue Pos merken */
  597.                 rp_box_x = repask[0].ob_x;
  598.                 rp_box_y = repask[0].ob_y;
  599.                 if (antw == RANEIN)                    /* Nicht ersetzen */
  600.                 {
  601.                     if (runter)
  602.                     {
  603.                         text_x++;
  604.                         text_len--;
  605.                     }
  606.                     else
  607.                     {
  608.                         text_len = text_x+such_len-1;
  609.                         text_x = 0;
  610.                     }
  611.                     continue;
  612.                 }
  613.                 if (antw == RAABBRUCH)
  614.                 {
  615.                     erg = -1;
  616.                     break;
  617.                 }
  618.                 blk_demark(t_ptr);
  619.             }
  620.         }
  621.         anz ++;
  622.         get_undo_col(t_ptr);
  623.         COPYB(REALLOC(&start,text_x,delta),r_str,rpl_len);
  624.         t_ptr->cursor_line = start;
  625.         if (r_modus != RP_ALL)
  626.         {
  627.             make_chg(t_ptr->link,LINE_CHANGE,t_ptr->ypos);
  628.             restore_edit();
  629.             if (r_modus == RP_FIRST) break;
  630.         }
  631.         if (runter)
  632.         {
  633.             text_x += rpl_len;
  634.             text_len += delta;
  635.             text_len -= rpl_len;
  636.         }
  637.         else
  638.         {
  639.             text_len = text_x;
  640.             text_x = 0;
  641.         }
  642.     }
  643.     Last_mouse();
  644.     if (anz > 0L)
  645.     {
  646.         t_ptr->moved++;
  647.         make_chg(t_ptr->link,POS_CHANGE,0);         /* wg. `*'    */
  648.         if (r_modus==RP_ALL)
  649.         {
  650.             if (t_ptr->block && !special)
  651.             {
  652.                 t_ptr->p1 = get_line(&t_ptr->text,t_ptr->z1);
  653.                 t_ptr->p2 = get_line(&t_ptr->text,t_ptr->z2);
  654.                 blk_demark(t_ptr);
  655.             }
  656.             make_chg(t_ptr->link,TOTAL_CHANGE,0);
  657.         }
  658.         if (r_modus != RP_FIRST && !special)
  659.         {
  660.             UBYTE    info[50];
  661.  
  662.             sprintf(info, STRING(REPLACESTR), anz);
  663.             set_info(t_ptr, info);
  664.         }
  665.         if (erg!=-1)
  666.             erg = 1;
  667.     }
  668.     else
  669.         if (erg!=-1) erg = 0;
  670.     if (!special)
  671.         restore_edit();
  672.     return erg;
  673. }
  674.  
  675. GLOBAL WORD do_next(TEXTP t_ptr)
  676. {
  677.     WORD    erg;
  678.     BOOLEAN    runter;
  679.  
  680.     runter = (global_shift) ? (!s_runter) : s_runter;
  681.     set_suchmode(s_str, s_grkl, s_quant, runter, s_wort, FALSE, s_round);
  682.     if (last_op == 1)
  683.         erg = start_find(t_ptr,FALSE);
  684.     else if (last_op == 2)
  685.         erg = start_replace(t_ptr, FALSE);
  686.     else
  687.         erg = -1;
  688.     return erg;
  689. }
  690.  
  691. GLOBAL BOOLEAN filematch(CONST UBYTE *str, CONST UBYTE *m)
  692. {
  693.     UBYTE     *where, M[80];
  694.     WORD        i;
  695.     BOOLEAN    Quantor, Runter, Grkl, Wort, Modus, Round, Line_start;
  696.     WORD        Muster_len;
  697.     UBYTE     Muster[80];
  698.     SET        Group[SETANZ];
  699.     WORD        Setanz;
  700.     WORD        Delta[256];
  701.     WORD        cs_val;
  702.     BOOLEAN    myGRkl = FALSE;        /* Beim Vergleich Gro₧/Klein nicht unterscheiden */
  703.  
  704.     if ((str[0] == EOS) || (m[0] == EOS))
  705.         return FALSE;
  706.     
  707.     caseSens((UBYTE *)str, &cs_val);
  708.     if (cs_val == 0)        /* Echter GRkl-Unterscheidung (Minix/RAMDisk) */
  709.         myGRkl = TRUE;
  710.             
  711.     if ((m[0] == '*') && (m[1] == '.'))        /* Ist m eine Extension? */
  712.         myGRkl = FALSE;                            /* dann Gro₧ == klein! */
  713.  
  714.     Quantor = quantor;
  715.     Runter = runter;
  716.     Grkl = grkl;
  717.     Wort = wort;
  718.     Modus = modus;
  719.     Round = round;
  720.     Line_start = line_start;
  721.     Muster_len = muster_len;
  722.     COPYB(Muster, muster_txt,80);
  723.     for (i=0; i<SETANZ; i++)
  724.         setcpy(Group[i], group[i]);
  725.     Setanz = setanz;
  726.     COPYW(Delta, delta, 256 * (short)sizeof(WORD));
  727.  
  728.     M[0] = '^';                         /* match mu₧ vorne anfangen */
  729.     strcpy(M+1,m);
  730.     strcat(M,"$");                     /* match mu₧ hinten enden */
  731.     set_suchmode(M, myGRkl, TRUE, TRUE, FALSE, FALSE, FALSE);
  732.     where = STRSTR2((UBYTE*)str, (short) strlen(str), muster_txt, &i);
  733.     quantor = Quantor;
  734.     runter = Runter;
  735.     grkl = Grkl;
  736.     wort = Wort;
  737.     modus = Modus;
  738.     round = Round;
  739.     line_start = Line_start;
  740.     muster_len = Muster_len;
  741.     COPYB(muster_txt, Muster,80);
  742.     for (i=0; i<SETANZ; i++)
  743.         setcpy(group[i], Group[i]);
  744.     setanz = Setanz;
  745.     COPYW(delta, Delta, 256 * (short) sizeof(WORD));
  746.     return (where==str);
  747. }
  748.  
  749. /*****************************************************************************/
  750.  
  751. LOCAL UBYTE Umlaute[8][7] =
  752.                 { /* ä      Ä      ö      Ö      ü      Ü      ₧    */
  753.                   { 0x84, 0x8E, 0x94, 0x99, 0x81, 0x9A, 0x9E},    /* Atari */
  754.                   { 0xE4, 0xC4, 0xF6, 0xD6, 0xFC, 0xDC, 0xDF},    /* Latin */
  755.                   { 0x8A, 0x80, 0x9A, 0x85, 0x9F, 0x86, 0xA7},    /* Mac */
  756.                   { 0x84, 0x8E, 0x94, 0x99, 0x81, 0x9A, 0xE1},    /* PC */
  757.                   {  'a',  'A',  'o',  'O',  'u',  'U',  's'},    /* LaTeX */
  758.                   {  'a',  'A',  'o',  'O',  'u',  'U',  's'},    /* HTML */
  759.                   {  'a',  'A',  'o',  'O',  'u',  'U',  's'},    /* ASCII */
  760.                 };
  761.  
  762.  
  763. LOCAL VOID to_latex(UBYTE *new, WORD *j, WORD u)
  764. {
  765.     new[(*j)++] = '"';
  766.     new[(*j)++] = Umlaute[umlaut_to][u];
  767. }
  768.  
  769. LOCAL VOID to_ascii(UBYTE *new, WORD *j, WORD u)
  770. {
  771.     new[(*j)++] = Umlaute[umlaut_to][u];
  772.     if (u == 6)                                    /* ₧ -> ss */
  773.         new[(*j)++] = 's';
  774.     else
  775.         new[(*j)++] = 'e';
  776. }
  777.  
  778. LOCAL VOID to_html(UBYTE *new, WORD *j, WORD u)
  779. {
  780.     new[(*j)++] = '&';
  781.     new[(*j)++] = Umlaute[umlaut_to][u];
  782.     if (u == 6)                                    /* ₧ -> ß */
  783.     {
  784.         new[(*j)++] = 'z';
  785.         new[(*j)++] = 'l';
  786.         new[(*j)++] = 'i';
  787.         new[(*j)++] = 'g';
  788.     }
  789.     else                                            /* -> &[aouAOU]uml */
  790.     {
  791.         new[(*j)++] = 'u';
  792.         new[(*j)++] = 'm';
  793.         new[(*j)++] = 'l';
  794.     }
  795.     new[(*j)++] = ';';
  796. }
  797.  
  798. LOCAL VOID to_misc(UBYTE *new, WORD *j, WORD u)
  799. {
  800.     new[(*j)++] = Umlaute[umlaut_to][u];
  801. }
  802.  
  803.  
  804. LOCAL WORD change_line(UBYTE *zeile, UBYTE *new, WORD max_len)
  805. {
  806.     WORD        i, j, u;
  807.     BOOLEAN    changed = FALSE;
  808.  
  809.     i = 0;
  810.     j = 0;
  811.     while (i < (short) strlen(zeile))
  812.     {
  813.         for (u = 0; u <= 7; u++)
  814.             if (zeile[i] == Umlaute[umlaut_from][u])
  815.                 break;
  816.  
  817.         if (j >= max_len)
  818.             return -2;
  819.  
  820.         if (u < 7)
  821.         {
  822.             changed = TRUE;
  823.             if (umlaut_to == LaTeX)
  824.                 to_latex(new, &j, u);
  825.             else if (umlaut_to == ASCII)
  826.                 to_ascii(new, &j, u);
  827.             else if (umlaut_to == HTML)
  828.                 to_html(new, &j, u);
  829.             else
  830.                 to_misc(new, &j, u);
  831.         }
  832.         else
  833.             new[j++] = zeile[i];
  834.         i++;
  835.     }
  836.     new[j] = EOS;
  837.     if (changed)
  838.         return (j - i);
  839.     else
  840.         return -1;
  841. }
  842.  
  843.  
  844. GLOBAL VOID    change_umlaute(TEXTP t_ptr)
  845. {
  846.     LINEP        lauf;
  847.     UBYTE        new_txt[MAX_LINE_LEN + 1];
  848.     WORD        delta_len, x, max_len;
  849.     LONG        l;
  850.  
  851.     lauf = FIRST(&t_ptr->text);
  852.     if (lauf != NULL)
  853.     {
  854.         x = BildPos(t_ptr->xpos, t_ptr->cursor_line, TRUE, t_ptr->loc_opt->tabsize);
  855.         start_aktion(STRING(UMLAUTSTR), FALSE, t_ptr->text.lines);
  856.         l = 0;
  857.         Busy_mouse();
  858.  
  859.         /*
  860.          * Für den Fall, da₧ die Zeile zu lang wird, wird der Platz ermittelt,
  861.          * der für genau eine Umwandlung noch benötigt wird.
  862.         */
  863.         switch (umlaut_to)
  864.         {
  865.             case LaTeX :
  866.             case ASCII :
  867.                 max_len = (short)sizeof(new_txt) - 1;    /* Es kommt ein Zeichen dazu */
  868.                 break;
  869.             case HTML :
  870.                 max_len = (short)sizeof(new_txt) - 6;    /* Es kommen sechs dazu */
  871.                 break;
  872.             default:
  873.                 max_len = (short)sizeof(new_txt);        /* Kein Gefahr, keine neuen Zeichen */
  874.                 break;
  875.         }
  876.         while (!IS_TAIL(lauf))
  877.         {
  878.             delta_len = change_line(TEXT(lauf), new_txt, max_len);
  879.             if (delta_len >= 0)
  880.             {
  881.                 t_ptr->moved++;
  882.                 if (delta_len > 0)                    /* Länge wurde erhöht */
  883.                     REALLOC(&lauf, 0, delta_len);
  884.                 COPYW(TEXT(lauf), new_txt, (short)strlen(new_txt));
  885.             }
  886.             else if (delta_len == -2)
  887.             {
  888.                 inote(1, TOOLONG, MAX_LINE_LEN);
  889.                 break;
  890.             }
  891.             NEXT(lauf);
  892.             do_aktion(++l);
  893.         }
  894.         Last_mouse();
  895.         end_aktion();
  896.         t_ptr->cursor_line = get_line(&t_ptr->text, t_ptr->ypos);
  897.         t_ptr->xpos = InterPos(x, t_ptr->cursor_line, TRUE, t_ptr->loc_opt->tabsize);
  898.         make_chg(t_ptr->link, POS_CHANGE, 0);         /* wg. `*'    */
  899.         make_chg(t_ptr->link, TOTAL_CHANGE, 0);
  900.         restore_edit();
  901.     }
  902. }
  903.  
  904. /* die Dialoge *************************************************************/
  905.  
  906. /*
  907.  * Die folgenden Tastenroutine wird bei den MyDials für die 'Find'-Dialoge
  908.  * eingeklickt, damit bei ^V im Editfeld jenes erst einmal gelöscht wird!!
  909.  */
  910. LOCAL WORD myKeys(OBJECT *tree, WORD edit_obj, WORD next_obj, WORD kr, WORD ks,
  911.                         WORD *onext_obj, UWORD *okr)
  912. {
  913.     UWORD nkc_key, ascii;
  914.     WORD    cpos;
  915.  
  916.     nkc_key = normkey(ks, kr);
  917.     ascii = nkc_key & 0x00FF;
  918.     if ( ((nkc_key & (NKF_FUNC|NKF_CTRL)) == (NKF_FUNC|NKF_CTRL) ) &&
  919.         ( ascii == 'V' ) )
  920.     {
  921.         cpos = 0;
  922.         objc_setstring(tree, edit_obj, "");
  923.  
  924.         dial_setcpos(tree, edit_obj, &cpos);
  925.         draw_Objc(tree, edit_obj, 1);
  926.     }
  927.     return NIL;         /* MyDials sollen nun ^V auswerten! */
  928. }
  929.  
  930.  
  931. LOCAL VOID insert_history(UBYTE *str)
  932. {
  933.     WORD    i,j;
  934.     UBYTE    old_history[HIST_ANZ][HIST_LEN+1];
  935.  
  936.     /* alte History merken */
  937.     memcpy(old_history[0], s_history[0], HIST_ANZ*(short)sizeof(s_history[0]));
  938.     strcpy(s_history[0], str);
  939.     j = 1;
  940.     for (i = 0; i < HIST_ANZ; i++)
  941.     {
  942.         /* jeden Eintrag nur einmal */
  943.         if ((old_history[i][0] != EOS) && (strcmp(old_history[i], s_history[0])!=0))
  944.         {
  945.             strcpy(s_history[j], old_history[i]);
  946.             j++;
  947.         }
  948.     }
  949. }
  950.  
  951.  
  952. LOCAL BOOLEAN build_popup(POPUP_STRUK *pop)
  953. {
  954.     UBYTE str[HIST_LEN + 1];
  955.     WORD    i;
  956.  
  957.     if (s_history[0][0] == EOS)
  958.         return FALSE;
  959.  
  960.     strcpy(str, " ");
  961.     strcat(str, s_history[0]);
  962.     for (i = (WORD)strlen(str); i < HIST_LEN; i++)
  963.         strcat(str, " ");
  964.  
  965.     create_popup(pop, HIST_ANZ, POPUPSTRG, str);
  966.     for (i = 1; i < HIST_ANZ; i++)
  967.     {
  968.         if (s_history[i][0] != EOS)
  969.         {
  970.             strcpy(str, " ");
  971.             strcat(str, s_history[i]);
  972.             append_popup(pop, POPUPSTRG, str);
  973.         }
  974.     }
  975.     if (pop->tree == NULL)
  976.         return FALSE;
  977.  
  978.     for(i = 0; i < pop->akt_item + 2; i++)
  979.         xrsrc_obfix(pop->tree, i);
  980.     dial_fix(pop->tree);
  981.  
  982.     return TRUE;
  983. }
  984.  
  985. LOCAL WORD hist_popup(OBJECT* tree, WORD obj_pos, WORD obj_text)
  986. {
  987.     WORD                y, ret;
  988.     POPUP_STRUK        pop;
  989.     POPDRAW_STRUK    p;
  990.  
  991.     ret = 0;
  992.     if (build_popup(&pop))
  993.     {
  994.         p.tree = pop.tree;
  995.         p.obj = 1;
  996.         objc_offset(tree, obj_pos, &p.x, &p.y);
  997.         p.center_obj = NIL;
  998.         p.ok = NULL;
  999.         p.bmsk = 3;
  1000.         p.relative = FALSE;
  1001.         p.docheck = FALSE;
  1002.         p.call_back = NULL;
  1003.         p.anz = 0;
  1004.         p.useranz = 0;
  1005.         p.pop_l = 0;
  1006.         p.pos = 0;
  1007.         p.akt = 0;
  1008.         p.oben = 0;
  1009.         p.unten = 0;
  1010.         y = popup_menu(&p);
  1011.         y -= pop.first_item;
  1012.         if (y >= 0)
  1013.         {
  1014.             objc_setstring(tree, obj_text, s_history[y]);
  1015.             draw_Objc(tree, obj_text, 1);
  1016.             ret = y;
  1017.         }
  1018.         free_popup(&pop);
  1019.     }
  1020.     return ret;
  1021. }
  1022.  
  1023.  
  1024. LOCAL WORD circle_popup(OBJECT* tree, WORD text_obj, WORD pos)
  1025. {
  1026.     if ((pos + 1 < HIST_ANZ) && (s_history[pos + 1][0] != EOS))
  1027.         pos++;
  1028.     else
  1029.         pos = 0;
  1030.     objc_setstring(tree, text_obj, s_history[pos]);
  1031.     draw_Objc(tree, text_obj, 1);
  1032.     return pos;
  1033. }
  1034.  
  1035.  
  1036. /* Suchen/Ersetzen in Texten, Suchen in Projekten */
  1037. /* 0: Abbruch 1: Suchen 2: Ersetzen */
  1038. GLOBAL WORD find_dial(BOOLEAN in_prj)
  1039. {
  1040.     WORD        antw, d, cycle;
  1041.     BOOLEAN    quit = FALSE, im_kreis;
  1042.     DIALINFO dial;
  1043.  
  1044.     do_icon(iclipbrd, DO_UPDATE);
  1045.  
  1046.     if (in_prj)
  1047.     {
  1048.         /* Hilfe: nur Suchen    */
  1049.         hide_objc(fhilfe, FHOK, FALSE);
  1050.         do_flags(fhilfe, FHOK, DEFAULT);
  1051.         hide_objc(fhilfe, FHNEXT,TRUE);
  1052.         undo_flags(fhilfe, FHNEXT, DEFAULT);
  1053.         hide_objc(fhilfe, FHRAUS, TRUE);
  1054.  
  1055.         hide_objc(replace, RPTITEL, TRUE);
  1056.         for (d = RPBOX; d <= RPALL; d++)
  1057.             disable_objc(replace, d, TRUE);
  1058.         disable_objc(replace, RPERSATZ, TRUE);
  1059.         disable_objc(replace, RPROUND, TRUE);
  1060.         disable_objc(replace, RPCURSOR, TRUE);
  1061.  
  1062.         select_objc(replace, RPGLOBAL, TRUE);
  1063.         select_objc(replace, RPCURSOR, FALSE);
  1064.         select_objc(replace, RPROUND, FALSE);
  1065.     }
  1066.     else
  1067.     {
  1068.         /* Hilfe: Suchen + Ersetzen */
  1069.         hide_objc(fhilfe, FHOK, TRUE);
  1070.         undo_flags(fhilfe, FHOK, DEFAULT);
  1071.         hide_objc(fhilfe, FHNEXT, FALSE);
  1072.         do_flags(fhilfe, FHNEXT, DEFAULT);
  1073.         hide_objc(fhilfe, FHRAUS, FALSE);
  1074.  
  1075.         hide_objc(replace, RPTITEL, FALSE);
  1076.         for (d = RPBOX; d <= RPALL; d++)
  1077.             disable_objc(replace, d, FALSE);
  1078.         disable_objc(replace, RPERSATZ, FALSE);
  1079.         disable_objc(replace, RPROUND, FALSE);
  1080.         disable_objc(replace, RPCURSOR, FALSE);
  1081.  
  1082.         select_objc(replace, RPGLOBAL, s_global);
  1083.         select_objc(replace, RPCURSOR, !s_global);
  1084.         select_objc(replace, RPROUND, s_round);
  1085.     }
  1086.  
  1087.     objc_setstring(replace, RPTEXT1, s_str);
  1088.     objc_setstring(replace, RPTEXT2, r_str);
  1089.     select_objc(replace, RPGRKL, s_grkl);
  1090.     select_objc(replace, RPWILD, s_quant);
  1091.     select_objc(replace, RPWORT, s_wort);
  1092.     select_objc(replace, RPRUNTER, s_runter);
  1093.     select_objc(replace, RPRAUF, !s_runter);
  1094.     select_objc(replace, RPFIRST, r_modus==RP_FIRST);
  1095.     select_objc(replace, RPALL, r_modus==RP_ALL);
  1096.     select_objc(replace, RPOPTION, r_modus==RP_OPT);
  1097.  
  1098.     /* Popup abschalten */
  1099.     disable_objc(replace, RPHIST, (s_history[0][0] == EOS));
  1100.     disable_objc(replace, RPHISTCIRC, (s_history[0][0] == EOS));
  1101.  
  1102.     Arrow_mouse();
  1103.     open_dial(replace, FALSE, NULL, &dial);
  1104.     set_Keybd(myKeys);
  1105.     dial_draw(&dial);
  1106.     cycle = 0;
  1107.     edobj = RPTEXT1;
  1108.     do
  1109.     {
  1110.         antw = dial_do(&dial, &edobj) & 0x7FFF;
  1111.         switch (antw)
  1112.         {
  1113.             case RPHISTCIRC :
  1114.                 cycle = circle_popup(replace, RPTEXT1, cycle);
  1115.                 break;
  1116.             case RPSTR :
  1117.             case RPHIST :
  1118.                 cycle = hist_popup(replace, RPHIST, RPTEXT1);
  1119.                 break;
  1120.             case RPHELP :
  1121.                 d = HndlDial(fhilfe, 0, FALSE, NULL, NULL);
  1122.                 if (d == FHNEXT)
  1123.                     HndlDial(rphilfe, 0, FALSE, NULL, NULL);
  1124.                 break;
  1125.             default:
  1126.                 quit = TRUE;
  1127.                 break;
  1128.         }
  1129.         select_objc(replace, antw, FALSE);
  1130.         draw_Objc(replace, antw, 1);
  1131.     }
  1132.     while (!quit);
  1133.     dial_end(&dial);
  1134.     Last_mouse();
  1135.     if (antw == RPOK || antw == RPERSATZ)
  1136.     {
  1137.         objc_getstring(replace, RPTEXT1, s_str);
  1138.         objc_getstring(replace, RPTEXT2, r_str);
  1139.         if ((strcmp(s_str, r_str) == 0) && (antw == RPERSATZ))
  1140.         {
  1141.             note(1, RPSAME);
  1142.             return 0;
  1143.         }
  1144.         s_grkl    = get_select(replace,RPGRKL);
  1145.         s_quant    = get_select(replace,RPWILD);
  1146.         s_wort    = get_select(replace,RPWORT);
  1147.         s_runter = get_select(replace,RPRUNTER);
  1148.         s_global = get_select(replace,RPGLOBAL);
  1149.         s_round    = get_select(replace,RPROUND);
  1150.         if (get_select(replace,RPFIRST))
  1151.             r_modus = RP_FIRST;
  1152.         else if (get_select(replace,RPALL))
  1153.             r_modus = RP_ALL;
  1154.         else
  1155.             r_modus = RP_OPT;
  1156.         if (s_str[0] != EOS)
  1157.             insert_history(s_str);
  1158.         im_kreis = s_round && (antw == RPOK);    /* 'im Kreis' nur bei Suchen, nicht beim Ersetzen */
  1159.         if (in_prj)
  1160.             set_suchmode(s_str, s_grkl, s_quant, s_runter, s_wort, TRUE, FALSE);
  1161.         else
  1162.             set_suchmode(s_str, s_grkl, s_quant, s_runter, s_wort, s_global, im_kreis);
  1163.         return((antw == RPOK) ? 1 : 2);
  1164.     }
  1165.     return(0);
  1166. }
  1167.  
  1168.  
  1169. /* Suchen auf Disk */
  1170. GLOBAL BOOLEAN diskfind_dial (UBYTE *df_path, UBYTE *df_name)
  1171. {
  1172.     PATH        name, str;
  1173.     UBYTE     *p;
  1174.     WORD        antw, cycle;
  1175.     FSEL        fsel;
  1176.     BOOLEAN    quit = FALSE;
  1177.     DIALINFO dial;
  1178.  
  1179.     do_icon(iclipbrd, DO_UPDATE);
  1180.     if (df_path[0]!=EOS)
  1181.     {
  1182.         make_shortpath(df_path,str,20);
  1183.         fill_ptext(diskfind, DFPATH, str);
  1184.     }
  1185.     else
  1186.         fill_ptext(diskfind, DFPATH, "");
  1187.     strcpy(name,df_path);
  1188.     objc_setstring(diskfind, DFFILE, df_name);
  1189.     objc_setstring(diskfind, DFTEXT, "");
  1190.     select_objc(diskfind,DFREK,df_rekursiv);
  1191.     select_objc(diskfind,DFGRKL,s_grkl);
  1192.     select_objc(diskfind,DFWILD,s_quant);
  1193.     select_objc(diskfind,DFWORT,s_wort);
  1194.     select_objc(diskfind,DFRAUF,!s_runter);
  1195.     select_objc(diskfind,DFRUNTER,s_runter);
  1196.  
  1197.     /* Popup abschalten */
  1198.     disable_objc(diskfind, DFHIST, (s_history[0][0] == EOS));
  1199.     disable_objc(diskfind, DFHISTCIRC, (s_history[0][0] == EOS));
  1200.  
  1201.     Arrow_mouse();
  1202.     open_dial(diskfind, FALSE, NULL, &dial);
  1203.     set_Keybd(myKeys);
  1204.     dial_draw(&dial);
  1205.     cycle = 0;
  1206.     edobj = DFFILE;
  1207.     do
  1208.     {
  1209.         antw = dial_do(&dial, &edobj) & 0x7FFF;
  1210.         switch (antw)
  1211.         {
  1212.             case DFHISTCIRC :
  1213.                 cycle = circle_popup(diskfind, DFTEXT, cycle);
  1214.                 break;
  1215.             case DFSTR :
  1216.             case DFHIST:
  1217.                 cycle = hist_popup(diskfind, DFHIST, DFTEXT);
  1218.                 break;
  1219.             case DFFSBOX:
  1220.                 strcpy(fsel.suffix,"*.*");
  1221.                 strcpy(fsel.name,"");
  1222.                 select_file(&fsel, name, STRING(SELPATHSTR));
  1223.                 if (name[0]!=EOS)
  1224.                 {
  1225.                     p = strrchr (name, '\\');
  1226.                     p[1] = EOS;
  1227.                     make_shortpath(name, str, 20);
  1228.                     fill_ptext(diskfind, DFPATH, str);
  1229.                 }
  1230.                 dial_draw(&dial);
  1231.                 break;
  1232.             case DFHELP :
  1233.                 HndlDial(dfhilfe, 0, FALSE, NULL, NULL);
  1234.                 break;
  1235.  
  1236.  
  1237.             default:
  1238.                 quit = TRUE;
  1239.                 break;
  1240.         }
  1241.         select_objc(diskfind, antw, FALSE);
  1242.         draw_Objc(diskfind, antw, 1);
  1243.     }
  1244.     while (!quit);
  1245.     dial_end(&dial);
  1246.     Last_mouse();
  1247.     if (antw == DFOK)
  1248.     {
  1249.         objc_getstring(diskfind, DFTEXT, s_str);
  1250.         objc_getstring(diskfind, DFFILE, df_name);
  1251.         df_rekursiv = get_select(diskfind,DFREK);
  1252.         s_runter = get_select(diskfind,DFRUNTER);
  1253.         s_grkl    = get_select(diskfind,DFGRKL);
  1254.         s_quant    = get_select(diskfind,DFWILD);
  1255.         s_wort    = get_select(diskfind,DFWORT);
  1256.         strcpy(df_path,name);
  1257.         if (s_str[0] != EOS)
  1258.             insert_history(s_str);
  1259.         set_suchmode(s_str, s_grkl, s_quant, s_runter, s_wort, TRUE, FALSE);
  1260.         return (TRUE);
  1261.     }
  1262.     return(FALSE);
  1263. }
  1264.  
  1265.  
  1266. GLOBAL BOOLEAN umlaut_dial(VOID)
  1267. {
  1268.     BOOLEAN        ret = FALSE, quit = FALSE;
  1269.     WORD            antw, save_from, save_to, y;
  1270.     DIALINFO        dial;
  1271.  
  1272.     save_from = umlaut_from;
  1273.     save_to = umlaut_to;
  1274.     if (global_shift)                    /* bei Shift: Quelle und Ziel vertauschen */
  1275.     {
  1276.         if (umlaut_to <= PC)            /* nur einbuchstabige können umgedreht werden! */
  1277.         {
  1278.             umlaut_from = save_to;
  1279.             umlaut_to = save_from;
  1280.         }
  1281.         else
  1282.         {
  1283.             mybeep();
  1284.             return FALSE;
  1285.         }
  1286.     }
  1287.     objc_setstring(umlautkonv, UVON, (UBYTE *)get_obspec(popups, UPFROMST + umlaut_from));
  1288.     objc_setstring(umlautkonv, UNACH, (UBYTE *)get_obspec(popups, UPTOST + umlaut_to));
  1289.  
  1290.     Arrow_mouse();
  1291.     open_dial(umlautkonv, FALSE, NULL, &dial);
  1292.     dial_draw(&dial);
  1293.     do
  1294.     {
  1295.         antw = dial_do(&dial, NULL) & 0x7FFF;
  1296.         switch (antw)
  1297.         {
  1298.             case UVSTR :
  1299.             case UVONCIRC :
  1300.             case UVON :
  1301.                 if (antw == UVONCIRC)
  1302.                     y = popup_select(NIL, umlautkonv, UVON, popups, UMLAUTPOP1, FALSE, DO_CYCLE, NULL, (POP_CB)NULL);
  1303.                 else
  1304.                     y = popup_select(NIL, umlautkonv, UVON, popups, UMLAUTPOP1, FALSE, DO_POPUP, NULL, (POP_CB)NULL);
  1305.                 y -= UPFROMST;
  1306.                 if (y >= 0)
  1307.                     umlaut_from = y;
  1308.                 break;
  1309.             case UNSTR :
  1310.             case UNACHCIRC :
  1311.             case UNACH :
  1312.                 if (antw == UNACHCIRC)
  1313.                     y = popup_select(NIL, umlautkonv, UNACH, popups, UMLAUTPOP2, FALSE, DO_CYCLE, NULL, (POP_CB)NULL);
  1314.                 else
  1315.                     y = popup_select(NIL, umlautkonv, UNACH, popups, UMLAUTPOP2, FALSE, DO_POPUP, NULL, (POP_CB)NULL);
  1316.                 y -= UPTOST;
  1317.                 if (y >= 0)
  1318.                     umlaut_to = y;
  1319.                 break;
  1320.             default:
  1321.                 quit = TRUE;
  1322.                 break;
  1323.         }
  1324.     }
  1325.     while (!quit);
  1326.     select_objc(umlautkonv, antw, FALSE);
  1327.     dial_end(&dial);
  1328.     if (antw == UKSTART)
  1329.     {
  1330.         if (umlaut_from == umlaut_to)
  1331.         {
  1332.             note(1, NOKONV);
  1333.             ret = FALSE;
  1334.         }
  1335.         else
  1336.             ret = TRUE;
  1337.     }
  1338.     if (ret == FALSE)
  1339.     {
  1340.         umlaut_from = save_from;
  1341.         umlaut_to = save_to;
  1342.     }
  1343.     Last_mouse();
  1344.     return ret;
  1345. }
  1346.